home *** CD-ROM | disk | FTP | other *** search
/ 9-Digit Zip Code Directory / 9-Digit Zip Code Directory (American Business Information) (ABIZIP-12).ISO / z4src.zip / D4DATA.HPP < prev    next >
C/C++ Source or Header  |  1993-03-03  |  16KB  |  383 lines
  1. /* d4data.hpp (c)Copyright Sequiter Software Inc., 1990-1993 All rights reserved. */
  2.  
  3. class S4CLASS Data4 ;
  4. class S4CLASS Index4 ;
  5. class S4CLASS Str4len ;
  6.  
  7. class S4CLASS Code4 : public CODE4
  8. {
  9. public:
  10.    Code4() ;
  11.    Code4( Code4& ) ;         /* Illegal operation, force link error */
  12.  
  13.    int     close_all()         { return d4close_all( this ) ; }
  14.    Data4   data( char *alias ) ;
  15.    int     error()             { return this->error_code ; }
  16.    int     error_set( int er ) { return e4set( this, er ) ; }
  17.    int     error( int er, char *p1 = 0, char *p2 = 0, char *p3 = 0 )
  18.                                { return e4describe( this, er, p1,p2,p3 ) ; }
  19.    void    exit()              {        e4exit( this ) ; }
  20.    void    exit_test()         {        e4exit_test( this ) ; }
  21.    int     flush_files()       { return d4flush_files( this ) ; }
  22.    int     init_undo()         { return d4init_undo( this ) ; }
  23.    int     opt_start()         { return d4opt_start( this ) ; }
  24.    int     opt_suspend()       { return d4opt_suspend( this ) ; }
  25.    int     unlock_files()      { return d4unlock_files( this ) ; }
  26.  
  27.    MEM4 *string_types[16] ;
  28. } ;
  29.  
  30. class S4CLASS Data4
  31. {
  32. public:
  33.    Data4()                           { data = 0 ; }
  34.    Data4( Code4 *code, char *name ) { data = d4open( code, name ) ; }
  35.  
  36.    char * alias()                   { return d4alias( data ) ; }
  37.    void   alias_set( char *ptr )    {        d4alias_set( data, ptr ) ; }
  38.    int    append()                  { return d4append( data ) ; }
  39.    int    append_data()             { return d4append_data( data ) ; }
  40.    int    append_blank()            { return d4append_blank( data ) ; }
  41.    int    append_start( int memo )  { return d4append_start( data, memo ) ; }
  42.    void   blank()                   {        d4blank( data ) ; }
  43.    int    bof()                     { return d4bof( data ) ; }
  44.    int    bottom()                  { return d4bottom( data ) ; }
  45.    int    changed( int flag )       { return d4changed( data, flag ) ; }
  46.    int    check()                   { return d4check( data ) ; }
  47.    int    close()            { int rc = d4close( data ) ; data = 0; return rc; }
  48.    int    create( Code4 *cd, char *name, FIELD4INFO *f, TAG4INFO *t = 0 )
  49.                                     { data = d4create( cd, name, f, t ) ;
  50.                                       return cd->error_code ; }
  51.    void   delete_rec()              {        d4delete( data ) ; }
  52.    int    deleted()                 { return d4deleted( data ) ; }
  53.    int    eof()                     { return d4eof( data ) ; }
  54.    FIELD4INFO * field_info()        { return d4field_info( data ) ; }
  55.    int    field_number( char *name) { return d4field_number( data, name) ; }
  56.    int    flush()                   { return d4flush( data ) ; }
  57.    int    flush_data()              { return d4flush_data( data ) ; }
  58.    int    free_blocks()             { return d4free_blocks( data ) ; }
  59.    int    go( long rec )            { return d4go( data, rec ) ; }
  60.    int    go_data( long rec )       { return d4go_data( data, rec ) ; }
  61.    int    go_eof()                  { return d4go_eof( data ) ; }
  62.    Index4 index( char *name ) ;
  63.    int    lock( long rec_num )      { return d4lock( data, rec_num ) ; }
  64.    int    lock_all()                { return d4lock_all( data ) ; }
  65.    int    lock_append()             { return d4lock_append( data ) ; }
  66.    int    lock_file()               { return d4lock_file( data ) ; }
  67.    int    lock_group(long *r, int n){ return d4lock_group( data, r, n ) ; }
  68.    int    lock_index()              { return d4lock_index( data ) ; }
  69.    int    lock_test( long rec )     { return d4lock_test( data, rec ) ; }
  70.    int    lock_test_append()        { return d4lock_test_append( data ) ; }
  71.    int    lock_test_file()          { return d4lock_test_file( data ) ; }
  72.    int    lock_test_index()         { return d4lock_test_index( data ) ; }
  73.    int    memo_compress()           { return d4memo_compress( data ) ; }
  74.    int    num_fields()              { return d4num_fields( data ) ; }
  75.    int    open( Code4 *code, char *name ) { data =  d4open( code, name ) ;
  76.                                       return code->error_code ; }
  77.    int    optimize( int opt_flag )  { return d4optimize( data, opt_flag ) ; }
  78.    int    optimize_write( int opt_flag )  { return d4optimize_write( data,  opt_flag ) ; }
  79.    int    pack()                    { return d4pack( data ) ; }
  80.    int    pack_data()               { return d4pack_data( data ) ; }
  81.    double position()                { return d4position( data ) ; }
  82.    int    position_set( double d )  { return d4position_set( data, d ) ; }
  83.    int    read( long rec,char *buf) { return d4read( data, rec, buf ) ; }
  84.    int    read_old( long rec )      { return d4read_old( data, rec ) ; }
  85.    void   recall()                  {        d4recall( data ) ; }
  86.    long   reccount()                { return d4reccount( data ) ; }
  87.    long   recno()                   { return d4recno( data ) ; }
  88.    char  *record()                  { return d4record( data ) ; }
  89.    long   record_position( long r ) { return d4record_position( data, r ) ; }
  90.    long   record_width()            { return d4record_width( data ) ; }
  91.    int    refresh()                 { return d4refresh( data ) ; }
  92.    int    refresh_record()          { return d4refresh_record( data ) ; }
  93.    int    reindex()                 { return d4reindex( data ) ; }
  94.    int    seek( char *ptr )         { return d4seek( data, ptr ) ; }
  95.    int    seek_double( double d )   { return d4seek_double( data, d ) ; }
  96.    int    skip( long n = 1 )        { return d4skip( data, n ) ; }
  97.    TAG4  *tag( char *name )         { return d4tag( data, name ) ; }
  98.    TAG4  *tag_default()             { return d4tag_default( data ) ; }
  99.    TAG4  *tag_next( TAG4 *tag )     { return d4tag_next( data, tag ) ; }
  100.    TAG4  *tag_prev( TAG4 *tag )     { return d4tag_prev( data, tag ) ; }
  101.    void   tag_select( TAG4 *tag )   {        d4tag_select( data, tag ) ; }
  102.    TAG4  *tag_selected()            { return d4tag_selected( data ) ; }
  103.    int    top()                     { return d4top( data ) ; }
  104.    int    unlock()                  { return d4unlock( data ) ; }
  105.    int    update_header(int t,int c){ return d4update_header( data, t, c ) ; }
  106.    int    validate_memo_ids()       { return d4validate_memo_ids( data ) ; }
  107.    int    write( long rec )         { return d4write( data, rec ) ; }
  108.    int    write_data( long rec )    { return d4write_data( data, rec ) ; }
  109.    int    write_keys( long rec )    { return d4write_keys( data, rec ) ; }
  110.    int    zap( long f, long last)   { return d4zap( data, f, last ) ; }
  111.    int    zap_data(long f,long last){ return d4zap_data( data, f, last ) ; }
  112.    
  113.    DATA4 *data ;
  114. } ;
  115.  
  116. class S4CLASS Index4 
  117. {
  118. public:
  119.    Index4()  { index = 0 ; }
  120.  
  121.    int    close()        { int rc =  i4close( index ) ; index = 0 ; return rc;}
  122.    int    create( Data4& data, char *name, TAG4INFO *info ) 
  123.                             { index = i4create( data.data, name, info ) ;
  124.                               return data.data->code_base->error_code ; }
  125.    int    lock()            { return i4lock( index ) ; }
  126.    int    open( Data4& data, char *file )  { index = i4open( data.data, file ) ;
  127.                               return data.data->code_base->error_code ; }
  128.    int    reindex()         { return i4reindex( index ) ; }
  129.    TAG4 *tag( char *name ) { return i4tag( index, name ) ; }
  130.    int    unlock()          { return i4unlock( index ) ; }
  131.  
  132.    INDEX4 *index ;
  133. } ;
  134.  
  135. class S4CLASS Str4len ;
  136.  
  137. class S4CLASS Str4
  138. {
  139. public:
  140.    #ifdef __ZTC__
  141.       virtual operator char() ;
  142.       virtual operator double() ;
  143.       virtual operator int() ;
  144.    #else
  145.       operator char() ;
  146.       operator double() ;
  147.       operator int() ;
  148.    #endif
  149.    virtual operator long() ;
  150.  
  151.    int  operator==( Str4& ) ;  /* Equal, including length */
  152.    int  operator>=( Str4& ) ;
  153.    int  operator<=( Str4& ) ;
  154.    int  operator< ( Str4& ) ;
  155.    int  operator> ( Str4& ) ;
  156.  
  157.    int    add( Str4& ) ;
  158.    int    assign( char *) ;
  159.    int    assign( char *ptr, unsigned ptr_len ) ;
  160.    int    assign( Str4& from ) ;
  161.    void   assign_double( double, int new_len = -1, int n_dec = -1 ) ;
  162.    void   assign_long( long, int new_len = -1, int zeros_in_front = 0 ) ;
  163.    char  *end_ptr() ;
  164.    int    insert( Str4&, unsigned pos= 0 ) ;
  165.    void   lower() ;
  166.    unsigned ncpy( char *to_ptr, unsigned to_len ) ;
  167.    int    replace( Str4&, unsigned pos= 0 ) ;
  168.    void   set( int chr_value ) ;
  169.    void   trim() ;
  170.    void   upper() ;
  171.  
  172.    /* Get information */
  173.    int    at( Str4& ) ;
  174.    Str4len  left( unsigned l ) ;
  175.    Str4len  right( unsigned l ) ;
  176.    Str4len  substr( unsigned pos, unsigned len ) ;
  177.    int    true() ;
  178.  
  179.    virtual void      changed()          {}
  180.    virtual int       decimals()         { return 0 ; }
  181.    virtual unsigned  len() ;
  182.    virtual unsigned  maximum()          { return len() ; }
  183.    virtual char     *ptr()  = 0 ;
  184.    virtual char     *str() ;
  185.    virtual int       set_len(unsigned)  { return -1 ; }
  186.    virtual int       set_max(unsigned)  { return -1 ; }
  187. } ;
  188.  
  189. class S4CLASS Str4char : public Str4
  190. {
  191. public:
  192.    Str4char( char ch ) { c = ch ; }
  193.    char    *ptr()     { return &c ; }
  194.    unsigned len()     { return 1 ; }
  195.  
  196. private:
  197.    char c ;
  198. } ;
  199.  
  200. class S4CLASS Str4ptr : public Str4
  201. {
  202. public:
  203.    Str4ptr( char *ptr )   { p =   ptr ; }
  204.    char *ptr()          { return p ; }
  205.    char *str()          { return p ; }
  206.  
  207.    char *p ;
  208. } ;
  209.  
  210. class S4CLASS Str4len : public Str4ptr
  211. {
  212. public:
  213.    Str4len( void *ptr, unsigned ptr_len ) : Str4ptr((char *)ptr)
  214.                    { cur_len =  ptr_len; }
  215.    unsigned len()  { return cur_len ; }
  216.    char *str()     { return Str4::str() ; }
  217.  
  218.    unsigned cur_len ;
  219. } ;
  220.  
  221. class S4CLASS Str4max : public Str4len
  222. {
  223. public:
  224.    Str4max( void *ptr, unsigned m ) : Str4len(ptr,m)  { max_len = m; }
  225.  
  226.    unsigned maximum() { return max_len ; }
  227.    int      set_len( unsigned) ;
  228.  
  229.    unsigned max_len ;
  230. } ;
  231.  
  232. /* The following classes  are always guaranteed to be null ended. */
  233. class S4CLASS Str4ten : public Str4
  234. {
  235. public:
  236.    Str4ten()          { cur_len = 0; buf[0] = 0; buf[10] = 0; }
  237.    Str4ten( char *p ) { cur_len = 0; buf[10] = 0; assign(Str4ptr(p)); }
  238.  
  239.    unsigned maximum()      { return 10 ; }
  240.    unsigned len()          { return cur_len; }
  241.    char    *ptr()          { return buf ; }
  242.    char    *str()          { return buf ; }
  243.    int      set_len(unsigned new_len) ;
  244.  
  245. private:
  246.    unsigned cur_len ;
  247.    char buf[12] ;
  248. } ;
  249.  
  250. class S4CLASS Str4large: public Str4
  251. {
  252. public:
  253.    Str4large()          { cur_len = 0; buf[0] = 0; buf[255] = 0; }
  254.    Str4large( char *p ) { cur_len = 0; buf[255] = 0; assign(Str4ptr(p)); }
  255.  
  256.    unsigned maximum()     { return 255 ; }
  257.    unsigned len()     { return cur_len; }
  258.    char    *ptr()     { return buf ; }
  259.    char    *str()     { return buf ; }
  260.    int      set_len(unsigned len) ;
  261.  
  262. private:
  263.    unsigned cur_len ;
  264.    char buf[256] ;
  265. } ;
  266.  
  267. class S4CLASS Str4flex : public Str4max
  268. {
  269. public:
  270.    Str4flex( Code4 * ) ;
  271.    Str4flex( Str4flex& ) ;
  272.   ~Str4flex() ;
  273.  
  274.    void *operator new( size_t ) ;
  275.    void operator delete( void * ) ;
  276.  
  277.    void    free() ;
  278.    int     set_max( unsigned ) ;
  279.    char   *str()        { return ptr() ; }
  280.  
  281.    Code4 *code_base ;
  282. } ;
  283.  
  284. class S4CLASS Field4 : public Str4
  285. {
  286. public:
  287.    Field4()                       { field =  0 ; }
  288.    Field4( Data4& d, int j )      { field =  d4field_j( d.data, j ) ; }
  289.    Field4( Data4& d, char *name ) { field =  d4field( d.data, name ) ; }
  290.  
  291.    void          changed()   { field->data->record_changed = 1 ; }
  292.    Data4         data() ;
  293.    int           decimals()  { return f4decimals(field) ; }
  294.    int           init( Data4&d, char *name )  
  295.                              { field = d4field( d.data, name ) ; 
  296.                                return (field == 0) ? -1 : 0 ; }
  297.    int           init( Data4&d, int j )  
  298.                              { field = d4field_j( d.data, j ) ; 
  299.                                return (field == 0) ? -1 : 0 ; }
  300.    unsigned      len()       { return f4len(field) ; }
  301.    char         *name()      { return f4name(field) ; }
  302.    int           type()      { return f4type(field) ; }
  303.    char         *ptr()       { return f4ptr(field) ; }
  304.  
  305.    FIELD4    *field ;
  306. } ;
  307.  
  308. class S4CLASS Field4memo : public Field4
  309. {
  310. public:
  311.    Field4memo( Data4& data, int j ) ;
  312.    Field4memo( Data4& data, char *name ) ;
  313.  
  314.    void changed() ;
  315.    void free()       { f4memo_free(field) ; }
  316.    unsigned len()    { return f4memo_len(field) ; }
  317.    int  set_len(unsigned new_len)   { return f4memo_set_len(field,new_len) ; }
  318.  
  319.    char *ptr()       { return f4memo_ptr(field) ; }
  320.    char *str()       { return f4memo_str(field) ; }
  321. } ;
  322.  
  323. class S4CLASS  Date4 : public Str4
  324. {
  325. public:
  326.    Date4()              { set( ' ' ) ; dt[8] = 0 ; }
  327.    Date4( long l )      { date4assign(dt, l) ; dt[8] = 0 ; }
  328.    Date4( char *p )     { u4ncpy( dt, p, sizeof(dt) ) ; }
  329.  
  330.    operator long()       { return date4long(dt) ; }
  331.  
  332.    void   assign(long l) { date4assign(dt,l) ; dt[8] = 0 ; }
  333.    char  *cdow()         { return date4cdow(dt) ; }
  334.    char  *cmonth()       { return date4cmonth(dt) ; }
  335.    int    day()          { return date4day(dt) ; }    /* Day of month  (1-31) */
  336.    int    dow()          { return date4dow(dt) ; }    /* Day of week   (1-7) */
  337.    void   format( char *result, char *pict ) { date4format( dt, result, pict ) ; }
  338.    double format_mdx()   { return date4format_mdx(dt) ; }
  339.    void   init( char *value, char *picture ) { date4init( dt, value, picture ) ; }
  340.    long   julian_day()   { return date4long(dt) ; }
  341.    int    month()        { return date4month(dt) ; }      /* Month of year (1-12) */
  342.    char  *str()          { return dt ; }
  343.    void   today()        { date4today(dt) ; }
  344.    int    year()         { return date4year(dt) ; } ;
  345.  
  346.    unsigned  len()       { return 8 ; }
  347.    char *ptr()           { return dt ; }
  348.  
  349. private:
  350.    char dt[9] ;
  351. } ;
  352.  
  353. class S4CLASS Relate4
  354. {
  355. public:
  356.    Relate4() { relate = 0 ; }
  357.    Relate4( Data4& data) { relate = relate4init( data.data ) ; }
  358.    Relate4( Relate4& master, Data4& slave, char *m_expr, TAG4 *t )
  359.                          { relate = relate4create_slave( master.relate, slave.data, m_expr, t ) ; }
  360.  
  361.    bottom()              { return relate4bottom( relate ) ; }
  362.    void changed()        { relate4changed( relate ) ; }
  363.    create_slave( Relate4& master, Data4& slave, char *m_expr, TAG4 *t )
  364.              { relate = relate4create_slave( master.relate, slave.data, m_expr, t ) ;
  365.                return slave.data->code_base->error_code ; }
  366.    do_all()              { return relate4do( relate ) ; }
  367.    do_one()              { return relate4do_one( relate ) ; }
  368.    error_action( int a ) { return relate4error_action( relate, a ) ; }
  369.    free( int p )         { return relate4free( relate, p ) ; }
  370.    init( Data4& data )   { relate = relate4init( data.data ) ; return data.data->code_base->error_code ; }
  371.    lock()                { return relate4lock( relate ) ; }
  372.    int next()            { return relate4next( &relate ) ; }
  373.    query_set( char *p )  { return relate4query_set( relate, p ) ; }
  374.    skip( long l = 1)     { return relate4skip( relate, l ) ; }
  375.    skip_enable( int do_enable ) { return relate4skip_enable( relate, do_enable ) ; }
  376.    sort_set( char *p )   { return relate4sort_set( relate, p ) ; }
  377.    top()                 { return relate4top( relate ) ; }
  378.    type( int p )         { return relate4type( relate, p ) ; }
  379.    unlock()              { return relate4unlock( relate ) ; }
  380.  
  381.    RELATE4 *relate ;
  382. } ;
  383.